package com.tbynet.jwp.admin.user;

import com.jfinal.aop.Inject;
import com.jfinal.core.JFinal;
import com.jfinal.kit.Kv;
import com.jfinal.kit.Ret;
import com.jfinal.kit.StrKit;
import com.jfinal.plugin.activerecord.Page;
import com.jfinal.upload.UploadFile;
import com.tbynet.jwp.admin.AdminController;
import com.tbynet.jwp.framework.bean.Permission;
import com.tbynet.jwp.framework.bean.Role;
import com.tbynet.jwp.framework.kit.PassKit;
import com.tbynet.jwp.service.spi.UserManager;
import com.tbynet.jwp.model.Options;
import com.tbynet.jwp.model.Usermeta;
import com.tbynet.jwp.model.Users;
import com.tbynet.jwp.repository.spi.OptionService;
import com.tbynet.jwp.repository.spi.UserService;
import net.coobird.thumbnailator.Thumbnails;

import java.io.File;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 用户管理控制器
 *
 * 核心职责：
 * 1. 用户列表展示和搜索
 * 2. 用户创建、编辑和删除
 * 3. 用户权限和角色管理
 * 4. 用户头像上传和管理
 *
 * 设计原则：
 * - 不包含业务逻辑，只负责请求处理和响应
 * - 参数验证和格式转换
 * - 统一的错误码和响应格式
 * - 清晰的职责划分和方法命名
 *
 * @author 佰亿互联
 * @version 3.0
 * @since 2025-11-04
 */
public class UserAdminController extends AdminController {

    // ========== 依赖注入 ==========

    /** 用户管理编排层 - 用于处理复杂业务逻辑 */
    @Inject
    private UserManager userManager;

    /** 用户服务层 - 用于简单数据操作 */
    @Inject
    private UserService userService;

    /** 配置服务层 - 用于获取系统配置 */
    @Inject
    private OptionService optionService;

    // ========== 配置常量 ==========

    /** 允许的头像文件类型 */
    private static final String[] ALLOWED_AVATAR_TYPES = {"jpg", "jpeg", "png", "gif"};

    /** 头像文件大小限制（2MB） */
    private static final long MAX_AVATAR_SIZE = 2 * 1024 * 1024;

    /** 头像缩略图宽度 */
    private static final int AVATAR_THUMBNAIL_WIDTH = 150;

    /** 头像缩略图高度 */
    private static final int AVATAR_THUMBNAIL_HEIGHT = 150;

    // ========== 页面渲染方法 ==========

    /**
     * 用户列表页面
     *
     * 功能说明：
     * - 显示用户管理主页面
     * - 保持搜索参数用于页面回显
     * - 渲染用户列表模板
     *
     * 访问路径：GET /admin/user
     */
    public void index() {
        try {
            logOperation("VIEW_USER_LIST", "查看用户列表", "开始", null);

            // 保持搜索参数用于页面回显
            keepPara("q");
            render("index.html");

            logOperation("VIEW_USER_LIST", "查看用户列表", "成功", null);

        } catch (Exception e) {
            logOperation("VIEW_USER_LIST", "查看用户列表", "失败", e.getMessage());
            handleSystemException(e, "加载用户列表页面");
        }
    }

    /**
     * 创建用户页面
     *
     * 功能说明：
     * - 显示用户创建表单页面
     * - 提供用户基本信息输入表单
     * - 渲染用户创建模板
     *
     * 访问路径：GET /admin/user/create
     */
    public void create() {
        try {
            logOperation("VIEW_CREATE_USER", "查看创建用户页面", "开始", null);

            render("create.html");

            logOperation("VIEW_CREATE_USER", "查看创建用户页面", "成功", null);

        } catch (Exception e) {
            logOperation("VIEW_CREATE_USER", "查看创建用户页面", "失败", e.getMessage());
            handleSystemException(e, "加载用户创建页面");
        }
    }

    /**
     * 编辑用户页面
     *
     * 功能说明：
     * - 显示用户编辑表单页面
     * - 加载指定用户的详细信息
     * - 提供用户信息修改表单
     *
     * 访问路径：GET /admin/user/edit
     */
    public void edit() {
        Object userId = get("user_id");
        long startTime = System.currentTimeMillis();

        try {
            logOperation("VIEW_EDIT_USER", "查看编辑用户页面", "开始", "用户ID: " + userId);

            // 参数验证
            if (userId == null) {
                handleParamError("user_id", "用户ID无效");
                return;
            }

            // 获取用户基本信息
            Users user = userService.getById(userId);
            if (user == null) {
                handleBusinessError("USER_NOT_FOUND", "用户不存在");
                return;
            }

            // 加载用户的所有元数据
            loadAllUserMetaData(user);
            set("user", user);
            render("edit.html");

            logOperation("VIEW_EDIT_USER", "查看编辑用户页面", "成功",
                    "用户ID: " + userId + ", 耗时: " + (System.currentTimeMillis() - startTime) + "ms");

        } catch (Exception e) {
            logOperation("VIEW_EDIT_USER", "查看编辑用户页面", "失败", e.getMessage());
            handleSystemException(e, "加载用户编辑页面");
        }
    }

    // ========== 数据操作方法 ==========

    /**
     * 搜索用户
     *
     * 功能说明：
     * - 根据关键词搜索用户
     * - 返回分页的用户列表
     * - 为用户数据补充角色和头像信息
     *
     * 访问路径：POST /admin/user/search
     */
    public void search() {
        String keyword = getPara("q");
        long startTime = System.currentTimeMillis();

        try {
            logOperation("SEARCH_USER", "搜索用户", "开始", "关键词: " + hideSensitiveInfo(keyword, 2, 2));

            // 调用Service层进行搜索
            Page<Users> page = userService.search(getPage(), getSize(), keyword);

            // 为用户数据补充额外信息
            for (Users user : page.getList()) {
                enrichUserWithRoleAndAvatar(user);
            }

            ok(Ret.by("data", page));

            logOperation("SEARCH_USER", "搜索用户", "成功",
                    "关键词: " + hideSensitiveInfo(keyword, 2, 2) +
                            ", 结果数量: " + page.getList().size() +
                            ", 耗时: " + (System.currentTimeMillis() - startTime) + "ms");

        } catch (Exception e) {
            logOperation("SEARCH_USER", "搜索用户", "失败", e.getMessage());
            handleSystemException(e, "搜索用户");
        }
    }

    /**
     * 保存用户（新增）
     *
     * 功能说明：
     * - 创建新用户
     * - 验证用户参数
     * - 调用Manager层处理用户创建业务
     *
     * 访问路径：POST /admin/user/save
     */
    public void save() {
        long startTime = System.currentTimeMillis();

        try {
            logOperation("CREATE_USER", "创建用户", "开始", null);

            // 1. 参数验证
            if (!validateCreateUserParams()) {
                return;
            }

            // 2. 构建用户对象
            Users user = buildUserForCreate();
            List<Usermeta> metas = buildUserMetasForCreate(user);

            // 3. 调用Manager层保存用户
            Ret result = userManager.createUser(user, metas);
            if (result.isOk()) {
                logOperation("CREATE_USER", "创建用户", "成功",
                        "用户ID: " + user.getID() + ", 用户名: " + hideSensitiveInfo(user.getUserLogin(), 2, 2));
                ok(Ret.by("msg", "添加用户成功").set("data", user.getID()));
            } else {
                logOperation("CREATE_USER", "创建用户", "失败",
                        "用户名: " + hideSensitiveInfo(user.getUserLogin(), 2, 2));
                fail("添加用户失败，请联系管理员");
            }

        } catch (Exception e) {
            logOperation("CREATE_USER", "创建用户", "异常", e.getMessage());
            handleSystemException(e, "创建用户");
        } finally {
            log.debug("用户创建处理完成，耗时: %sms", System.currentTimeMillis() - startTime);
        }
    }

    /**
     * 更新用户信息
     *
     * 功能说明：
     * - 更新现有用户信息
     * - 支持基本信息、密码、角色等更新
     * - 调用Manager层处理用户更新业务
     *
     * 访问路径：POST /admin/user/update
     */
    public void update() {
        String userId = get("user_id");
        long startTime = System.currentTimeMillis();

        try {
            logOperation("UPDATE_USER", "更新用户", "开始", "用户ID: " + userId);

            // 参数验证
            if (StrKit.isBlank(userId)) {
                handleParamError("user_id", "用户ID不能为空");
                return;
            }

            // 1. 验证用户存在性
            Users user = userService.getById(userId);
            if (user == null) {
                handleBusinessError("USER_NOT_FOUND", "用户不存在");
                return;
            }

            // 2. 更新用户信息
            updateUserFromParams(user);
            List<Usermeta> metas = buildUserMetasForUpdate(user);

            // 3. 调用Manager层更新用户
            Ret result = userManager.updateUser(user, metas);
            if (result.isOk()) {
                logOperation("UPDATE_USER", "更新用户", "成功", "用户ID: " + user.getID());
                ok(Ret.by("msg", "更新用户成功").set("data", user.getID()));
            } else {
                logOperation("UPDATE_USER", "更新用户", "失败", "用户ID: " + user.getID());
                fail("更新用户失败，请联系管理员");
            }

        } catch (Exception e) {
            logOperation("UPDATE_USER", "更新用户", "异常", e.getMessage());
            handleSystemException(e, "更新用户");
        } finally {
            log.debug("用户更新处理完成，用户ID: %s, 耗时: %sms", userId, System.currentTimeMillis() - startTime);
        }
    }

    /**
     * 删除用户
     *
     * 功能说明：
     * - 删除指定用户
     * - 清理用户相关数据
     * - 调用Manager层处理用户删除业务
     *
     * 访问路径：POST /admin/user/delete
     */
    public void delete() {
        String userId = getPara("user_id");
        long startTime = System.currentTimeMillis();

        try {
            logOperation("DELETE_USER", "删除用户", "开始", "用户ID: " + userId);

            // 参数验证
            if (StrKit.isBlank(userId)) {
                handleParamError("user_id", "用户ID不能为空");
                return;
            }

            // 调用Manager层删除用户
            Ret result = userManager.deleteUser(userId);
            if (result.isOk()) {
                logOperation("DELETE_USER", "删除用户", "成功", "用户ID: " + userId);
                ok(Ret.by("msg", "删除用户成功"));
            } else {
                logOperation("DELETE_USER", "删除用户", "失败", "用户ID: " + userId);
                fail("删除用户失败，请联系管理员");
            }

        } catch (Exception e) {
            logOperation("DELETE_USER", "删除用户", "异常", e.getMessage());
            handleSystemException(e, "删除用户");
        } finally {
            log.debug("用户删除处理完成，用户ID: %s, 耗时: %sms", userId, System.currentTimeMillis() - startTime);
        }
    }

    /**
     * 获取角色权限列表
     *
     * 功能说明：
     * - 根据角色名称获取对应的权限列表
     * - 用于前端权限选择和显示
     *
     * 访问路径：GET /admin/user/permission
     */
    public void permission() {
        String role = getPara("role");
        long startTime = System.currentTimeMillis();

        try {
            logOperation("GET_PERMISSIONS", "获取权限列表", "开始", "角色: " + role);

            // 参数验证
            if (StrKit.isBlank(role)) {
                handleParamError("role", "角色不能为空");
                return;
            }

            // 调用Manager层获取权限列表
            List<String> permissions = userManager.getUserPermissions(role);
            ok(Ret.by("data", permissions));

            logOperation("GET_PERMISSIONS", "获取权限列表", "成功",
                    "角色: " + role + ", 权限数量: " + permissions.size() +
                            ", 耗时: " + (System.currentTimeMillis() - startTime) + "ms");

        } catch (Exception e) {
            logOperation("GET_PERMISSIONS", "获取权限列表", "失败", e.getMessage());
            handleSystemException(e, "获取权限列表");
        }
    }

    /**
     * 上传用户头像
     *
     * 功能说明：
     * - 处理用户头像文件上传
     * - 生成缩略图和保存文件
     * - 更新用户头像元数据
     *
     * 访问路径：POST /admin/user/avatar
     */
    public void avatar() {
        long startTime = System.currentTimeMillis();

        try {
            logOperation("UPLOAD_AVATAR", "上传头像", "开始", null);

            UploadFile uploadFile = getFile("file", "/avatar");
            Long userIdLong = getLong("uid");

            // 参数验证
            if (uploadFile == null) {
                handleParamError("file", "请选择要上传的文件");
                return;
            }

            if (userIdLong == null) {
                handleParamError("uid", "用户ID不能为空");
                return;
            }

            // 验证文件类型和大小
            if (!validateAvatarFile(uploadFile)) {
                return;
            }

            // 将Long转换为BigInteger
            BigInteger userId = BigInteger.valueOf(userIdLong);

            // 处理头像文件
            String avatarUrl = processAvatarUpload(uploadFile, userId);

            // 更新用户头像元数据
            boolean success = updateUserAvatarMeta(userId, avatarUrl);
            if (success) {
                logOperation("UPLOAD_AVATAR", "上传头像", "成功",
                        "用户ID: " + userId + ", 头像URL: " + avatarUrl);
                ok(Ret.by("data", avatarUrl));
            } else {
                logOperation("UPLOAD_AVATAR", "上传头像", "失败", "用户ID: " + userId);
                fail("保存头像信息失败");
            }

        } catch (Exception e) {
            logOperation("UPLOAD_AVATAR", "上传头像", "异常", e.getMessage());
            handleSystemException(e, "上传头像");
        } finally {
            log.debug("头像上传处理完成，耗时: %sms", System.currentTimeMillis() - startTime);
        }
    }

    // ========== 私有方法：参数验证 ==========

    /**
     * 验证创建用户参数
     *
     * @return 验证是否通过
     */
    private boolean validateCreateUserParams() {
        String userLogin = getPara("user_login");
        String email = getPara("email");
        String userPass = getPara("user_pass");

        // 基本参数验证
        if (!validateRequired("user_login", "用户名")) return false;
        if (!validateRequired("email", "电子邮件")) return false;
        if (!validateRequired("user_pass", "密码")) return false;

        // 邮箱格式验证
        if (!validateEmail(email, "电子邮件")) return false;

        // 密码长度验证
        if (!validateLength(userPass, 6, 100, "密码")) return false;

        // 用户名唯一性验证
        if (userService.isUserLoginExists(userLogin)) {
            handleParamError("user_login", "用户名已存在");
            return false;
        }

        // 邮箱唯一性验证
        if (userService.isEmailExists(email)) {
            handleParamError("email", "邮箱已被使用");
            return false;
        }

        return true;
    }

    /**
     * 验证头像文件
     *
     * @param uploadFile 上传的文件对象
     * @return 验证是否通过
     */
    private boolean validateAvatarFile(UploadFile uploadFile) {
        String fileName = uploadFile.getFileName();
        long fileSize = uploadFile.getFile().length();

        // 验证文件类型
        if (!validateFileType(fileName, ALLOWED_AVATAR_TYPES, "头像文件")) {
            return false;
        }

        // 验证文件大小
        if (!validateFileSize(fileSize, MAX_AVATAR_SIZE, "头像文件")) {
            return false;
        }

        return true;
    }

    // ========== 私有方法：数据构建 ==========

    /**
     * 构建创建用户对象
     *
     * @return 用户对象实例
     */
    private Users buildUserForCreate() {
        String userLogin = getPara("user_login");
        String email = getPara("email");
        String userPass = getPara("user_pass");
        String url = getPara("url", "");
        String firstName = getPara("first_name");
        String lastName = getPara("last_name");

        Users user = new Users();

        // 设置基本信息
        user.setUserLogin(userLogin);
        user.setUserPass(PassKit.encrypt(userPass));
        user.setUserEmail(email);
        user.setUserUrl(url);
        user.setUserNicename(userLogin);
        user.setDisplayName(userLogin);
        user.setUserRegistered(new Date());
        user.setUserStatus(0);

        // 设置默认元数据值
        user.setNickname(userLogin);
        user.setFirstName(firstName);
        user.setLastName(lastName);
        user.setDescription("");
        user.setRichEditing("true");
        user.setSyntaxHighlighting("true");
        user.setCommentShortcuts("false");
        user.setAdminColor("fresh");
        user.setUseSSL("0");
        user.setShowAdminBarFront("true");
        user.setLocale("");
        user.setWpUserLevel("0");
        user.setDismissedWpPointers("wp496_privacy");

        return user;
    }

    /**
     * 构建创建用户的元数据
     *
     * @param user 用户对象
     * @return 元数据列表
     */
    private List<Usermeta> buildUserMetasForCreate(Users user) {
        List<Usermeta> metas = new ArrayList<>();
        String role = getPara("role");
        boolean sendUserNotification = getParaToBoolean("send_user_notification", false);

        // 添加角色元数据
        if (StrKit.notBlank(role)) {
            Usermeta roleMeta = new Usermeta();
            roleMeta.setUserId(user.getID());
            roleMeta.setMetaKey(Usermeta.role);
            roleMeta.setMetaValue(role);
            metas.add(roleMeta);

            // 添加权限元数据
            Usermeta permissionMeta = new Usermeta();
            permissionMeta.setUserId(user.getID());
            permissionMeta.setMetaKey(Usermeta.permissions);

            List<Kv> permissions = new ArrayList<>();
            for (Permission permission : Role.getPermissions(role)) {
                permissions.add(Kv.by(permission.getName(),
                        Kv.by("action", permission.getAction()).set("scope", permission.getScope())));
            }

            // 处理权限设置异常
            try {
                permissionMeta.setPermissions(permissions.toArray(new Kv[0]));
                metas.add(permissionMeta);
            } catch (Exception e) {
                log.error("设置用户权限失败，用户ID: %s", user.getID(), e);
                // 记录日志，但不中断用户创建流程
            }
        }

        // 发送用户通知（如果启用）
        if (sendUserNotification) {
            // TODO: 发送用户创建通知邮件
            log.info("需要发送用户创建通知，用户: %s", hideSensitiveInfo(user.getUserLogin(), 2, 2));
        }

        log.debug("构建创建用户元数据完成，用户ID: %s, 元数据数量: %s", user.getID(), metas.size());
        return metas;
    }

    /**
     * 从请求参数更新用户信息
     *
     * @param user 要更新的用户对象
     */
    private void updateUserFromParams(Users user) {
        String displayName = getPara("display_name");
        String email = getPara("email");
        String url = getPara("url", "");
        String userPass = getPara("user_pass");

        // 更新基本信息
        user.setDisplayName(displayName);
        user.setUserEmail(email);
        user.setUserUrl(url);

        // 如果提供了新密码，则更新密码
        if (StrKit.notBlank(userPass)) {
            user.setUserPass(PassKit.encrypt(userPass));
        }
    }

    /**
     * 构建更新用户的元数据
     *
     * @param user 用户对象
     * @return 元数据列表
     */
    private List<Usermeta> buildUserMetasForUpdate(Users user) {
        List<Usermeta> metas = new ArrayList<>();

        // 基本信息元数据
        addUserMetaIfPresent(metas, user, Usermeta.first_name, getPara("first_name"));
        addUserMetaIfPresent(metas, user, Usermeta.last_name, getPara("last_name"));
        addUserMetaIfPresent(metas, user, Usermeta.nickname, getPara("nickname"));
        addUserMetaIfPresent(metas, user, Usermeta.locale, getPara("locale"));
        addUserMetaIfPresent(metas, user, Usermeta.description, getPara("description"));
        addUserMetaIfPresent(metas, user, Usermeta.admin_color, getPara("admin_color"));
        addUserMetaIfPresent(metas, user, Usermeta.rich_editing, getPara("rich_editing"));
        addUserMetaIfPresent(metas, user, Usermeta.comment_shortcuts, getPara("comment_shortcuts"));
        addUserMetaIfPresent(metas, user, Usermeta.show_admin_bar_front, getPara("admin_bar_front"));
        addUserMetaIfPresent(metas, user, Usermeta.simple_local_avatar, get("simple_local_avatar"));

        // 角色元数据
        String role = getPara("role");
        if (StrKit.notBlank(role)) {
            Usermeta roleMeta = getOrCreateUserMeta(user, Usermeta.role);
            roleMeta.setRole(role);
            metas.add(roleMeta);
        }

        // 权限元数据
        String[] permissions = getParaValues("permission");
        if (permissions != null && permissions.length > 0) {
            Usermeta permissionMeta = getOrCreateUserMeta(user, Usermeta.permissions);

            List<Kv> permissionList = new ArrayList<>();
            for (String name : permissions) {
                Permission permission = Permission.getPermission(name);
                if (permission != null) {
                    permissionList.add(Kv.by(permission.getName(),
                            Kv.by("action", permission.getAction()).set("scope", permission.getScope())));
                }
            }

            // 处理权限设置异常
            try {
                permissionMeta.setPermissions(permissionList.toArray(new Kv[0]));
                metas.add(permissionMeta);
            } catch (Exception e) {
                log.error("更新用户权限失败，用户ID: %s", user.getID(), e);
                // 记录日志，但不中断用户更新流程
            }
        }

        log.debug("构建更新用户元数据完成，用户ID: %s, 元数据数量: %s", user.getID(), metas.size());
        return metas;
    }

    // ========== 私有方法：数据处理 ==========

    /**
     * 为用户数据补充角色和头像信息
     *
     * @param user 用户对象
     */
    private void enrichUserWithRoleAndAvatar(Users user) {
        // 添加角色信息
        Usermeta roleMeta = userService.getUserMeta(user.getID(), Usermeta.role);
        if (roleMeta != null) {
            user.put(Usermeta.role, roleMeta.getMetaValue());
        }

        // 添加头像信息
        Usermeta avatarMeta = userService.getUserMeta(user.getID(), Usermeta.simple_local_avatar);
        if (avatarMeta != null) {
            user.put(Usermeta.simple_local_avatar, avatarMeta.getMetaValue());
        }
    }

    /**
     * 加载用户的所有元数据
     *
     * @param user 用户对象
     */
    private void loadAllUserMetaData(Users user) {
        long startTime = System.currentTimeMillis();

        try {
            List<Usermeta> metas = userService.getUserMetas(user.getID());
            for (Usermeta meta : metas) {
                try {
                    switch (meta.getMetaKey()) {
                        case Usermeta.session_tokens:
                            set(meta.getMetaKey(), meta.getSessionTokens());
                            break;
                        case Usermeta.permissions:
                            user.put(meta.getMetaKey(), meta.getPermissions().toLinkedHashMap());
                            break;
                        case Usermeta.wp_capabilities:
                            set(meta.getMetaKey(), meta.getWpCapabilities().toLinkedHashMap());
                            break;
                        default:
                            user.put(meta.getMetaKey(), meta.getMetaValue());
                            break;
                    }
                } catch (Exception e) {
                    log.error("解析用户元数据失败，用户ID: %s, 元数据键: %s", user.getID(), meta.getMetaKey(), e);
                    // 单个元数据解析失败不影响整体
                }
            }

            log.debug("用户所有元数据加载完成，用户ID: %s, 数量: %s, 耗时: %sms",
                    user.getID(), metas.size(), System.currentTimeMillis() - startTime);

        } catch (Exception e) {
            log.error("加载用户所有元数据失败，用户ID: %s", user.getID(), e);
        }
    }

    /**
     * 处理头像文件上传
     *
     * @param uploadFile 上传的文件对象
     * @param userId 用户ID
     * @return 头像访问URL
     * @throws Exception 文件处理异常
     */
    private String processAvatarUpload(UploadFile uploadFile, BigInteger userId) throws Exception {
        File file = uploadFile.getFile();
        String fileName = uploadFile.getFileName();
        String suffix = fileName.substring(fileName.lastIndexOf("."));
        String newFileName = userId.toString() + suffix;
        String uploadPath = uploadFile.getUploadPath();

        // 使用Thumbnails处理图片（生成缩略图）
        File outputFile = new File(uploadPath + File.separator + newFileName);
        Thumbnails.of(file)
                .size(AVATAR_THUMBNAIL_WIDTH, AVATAR_THUMBNAIL_HEIGHT)
                .keepAspectRatio(false)
                .toFile(outputFile);

        // 删除临时文件
        file.delete();

        // 获取站点URL
        String siteUrl = optionService.getOption(Options.siteurl).getOptionValue();

        // 构建完整的头像URL
        return siteUrl + File.separator +
                JFinal.me().getConstants().getBaseUploadPath() +
                "/avatar" + File.separator + newFileName;
    }

    /**
     * 更新用户头像元数据
     *
     * @param userId 用户ID
     * @param avatarUrl 头像URL
     * @return 更新是否成功
     */
    private boolean updateUserAvatarMeta(BigInteger userId, String avatarUrl) {
        try {
            Usermeta avatarMeta = userService.getUserMeta(userId, Usermeta.simple_local_avatar);
            if (avatarMeta == null) {
                avatarMeta = new Usermeta();
                avatarMeta.setUserId(userId);
                avatarMeta.setMetaKey(Usermeta.simple_local_avatar);
            }
            avatarMeta.setSimpleLocalAvatar(avatarUrl);

            boolean result = userService.saveOrUpdateUsermeta(avatarMeta);
            log.debug("更新用户头像元数据完成，用户ID: %s, 结果: %s", userId, result);
            return result;

        } catch (Exception e) {
            log.error("更新用户头像元数据失败，用户ID: %s", userId, e);
            return false;
        }
    }

    // ========== 私有方法：辅助工具 ==========

    /**
     * 如果参数存在则添加用户元数据
     */
    private void addUserMetaIfPresent(List<Usermeta> metas, Users user, String metaKey, String metaValue) {
        if (StrKit.notBlank(metaValue)) {
            Usermeta meta = getOrCreateUserMeta(user, metaKey);
            setMetaValueByKey(meta, metaKey, metaValue);
            metas.add(meta);
        }
    }

    /**
     * 获取或创建用户元数据
     */
    private Usermeta getOrCreateUserMeta(Users user, String metaKey) {
        Usermeta meta = userService.getUserMeta(user.getID(), metaKey);
        if (meta == null) {
            meta = new Usermeta();
            meta.setUserId(user.getID());
            meta.setMetaKey(metaKey);
        }
        return meta;
    }

    /**
     * 根据元数据键设置值
     */
    private void setMetaValueByKey(Usermeta meta, String metaKey, String value) {
        switch (metaKey) {
            case Usermeta.first_name:
                meta.setFirstName(value);
                break;
            case Usermeta.last_name:
                meta.setLastName(value);
                break;
            case Usermeta.nickname:
                meta.setNickname(value);
                break;
            case Usermeta.locale:
                meta.setLocale(value);
                break;
            case Usermeta.description:
                meta.setDescription(value);
                break;
            case Usermeta.admin_color:
                meta.setAdminColor(value);
                break;
            case Usermeta.rich_editing:
                meta.setRichEditing(value);
                break;
            case Usermeta.comment_shortcuts:
                meta.setCommentShortcuts(value);
                break;
            case Usermeta.show_admin_bar_front:
                meta.setShowAdminBarFront(value);
                break;
            case Usermeta.simple_local_avatar:
                meta.setSimpleLocalAvatar(value);
                break;
            default:
                meta.setMetaValue(value);
                break;
        }
    }
}